home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / amiga / gui / prcgntn1.lha / Precognition / source / stringlist.c < prev    next >
C/C++ Source or Header  |  1992-12-23  |  6KB  |  250 lines
  1.  
  2. #include "StringList.h"
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include "amigamem.h"
  6.  
  7. #define QUALFLAG (BYTE*) -1
  8.  
  9. void StringList_Init( StringList *slist, BOOL Qualify )
  10. {
  11.    slist->Entries    = NULL;
  12.    slist->nEntries   = 0;
  13.    slist->Qualifiers = (Qualify ? QUALFLAG : 0);
  14. }
  15.  
  16. #ifdef STRINGLIST_VERBOSE
  17.  
  18. void dump_StringList( StringList *list )
  19. {
  20.    int i;
  21.    
  22.    printf("dump_StringList: nEntries=%d\n", list->nEntries );
  23.    
  24.    for (i=0; i<list->nEntries; i++)
  25.       printf("%d (%d), %s\n", 
  26.          i, list->Entries[i], list->Entries[i] );
  27. }
  28.  
  29. #endif
  30.  
  31. void StringList_CleanUp( StringList *slist )
  32. {  
  33.    StringList_DeleteAllStrings( slist );
  34. }
  35.  
  36. BOOL StringList_AddString( StringList *slist,
  37.                            char       *string,
  38.                            BYTE        qualifiers )
  39. {
  40.    char **new_entries;
  41.    BYTE  *new_quals;
  42.    char *new_entry;
  43.    USHORT n, i;
  44.  
  45.    n = slist->nEntries + 1;
  46.    /*printf("about to malloc\n");*/
  47.    if (new_entries = (char**) Amalloc( sizeof(char*) * n ))
  48.    {
  49.       /*printf("copying to new array...\n");*/
  50.       for (i=0; i<slist->nEntries; i++)
  51.          new_entries[i] = slist->Entries[i];
  52.       /*printf("StringList_AddString: adding new string, n=%d, string=\"%s\"\n", n, string);*/
  53.       new_entries[n-1] = new_entry = Astrdup( string );
  54.  
  55.       if (slist->Qualifiers)
  56.       {
  57.          /*printf("doing qualifiers...\n");*/
  58.          if (new_quals = (BYTE*) Amalloc( sizeof(BYTE) * n ))
  59.          {
  60.             for (i=0; i<slist->nEntries; i++)
  61.                new_quals[i] = slist->Qualifiers[i];
  62.  
  63.             new_quals[n-1] = qualifiers;
  64.             /*printf("finished qualifiers!\n");*/
  65.  
  66.             Afree( slist->Entries );
  67.             if (slist->Qualifiers != QUALFLAG)
  68.               Afree( slist->Qualifiers );
  69.             slist->Entries    = new_entries;
  70.             slist->nEntries++;
  71.             slist->Qualifiers = new_quals;
  72.             /*printf("StringList_AddString : DONE!\n");*/
  73.             return TRUE;
  74.          }
  75.          else
  76.          {
  77.             /*printf("couldn't allocate qualifiers\n");*/
  78.             Afree( new_entry );
  79.             Afree( new_entries );
  80.             return FALSE;
  81.          }
  82.       }
  83.       else
  84.       {
  85.          Afree( slist->Entries );
  86.          slist->Entries = new_entries;
  87.          slist->nEntries++;
  88.          return TRUE;
  89.       }
  90.    }
  91.    else
  92.    {
  93.       ; /*printf("StringList_AddString: Amalloc failed.\n");*/
  94.    }
  95.    return FALSE;
  96. }
  97.  
  98. BOOL StringList_DeleteString( StringList *slist, USHORT n )
  99. {
  100.    USHORT i;
  101.  
  102.  
  103.    if (n >= slist->nEntries) return FALSE;
  104.  
  105. /*DUMPWAIT("StringList_DeleteString: before Afree\n");*/
  106.    Afree( slist->Entries[n] );
  107. /*DUMPWAIT("StringList_DeleteString: after Afree\n");*/
  108.    
  109.    for (i=n; i<slist->nEntries-1; i++)
  110.    {
  111.       slist->Entries[i] = slist->Entries[i+1];
  112.       if (slist->Qualifiers)
  113.          slist->Qualifiers[i] = slist->Qualifiers[i+1];
  114.    }
  115.    slist->nEntries--;
  116.  
  117.    slist->Entries = (char**) Arealloc( slist->Entries,
  118.                                        sizeof(char*)*slist->nEntries );
  119.    if (slist->Qualifiers)
  120.    {
  121.       if (slist->nEntries)
  122.          slist->Qualifiers = (BYTE*) Arealloc( slist->Qualifiers,
  123.                                                sizeof(BYTE)*slist->nEntries );
  124.       else
  125.          slist->Qualifiers = QUALFLAG;
  126.    }
  127.  
  128.  /*DUMPWAIT("end StringList_DeleteString\n");*/
  129.  
  130.    return TRUE;
  131. }
  132.  
  133. BOOL StringList_DeleteAllStrings( StringList *slist )
  134. {
  135.    int i;
  136.    
  137.    for (i=0; i<slist->nEntries; i++)
  138.    {
  139.       Afree( slist->Entries[i] ); 
  140.    }
  141.  
  142.    if (slist->Entries)
  143.    {
  144.       Afree(slist->Entries);
  145.       slist->Entries=NULL;
  146.    }
  147.    if ((slist->Qualifiers) && (slist->Qualifiers != QUALFLAG))
  148.    {
  149.       Afree(slist->Qualifiers);
  150.       slist->Qualifiers = QUALFLAG;
  151.    }
  152.    slist->nEntries = 0;
  153.    return TRUE;
  154. }
  155.  
  156. void StringList_Sort( StringList *slist )
  157. {
  158.    USHORT j, i, i1;
  159.    char *e_i, *e_i1;
  160.    BYTE q;
  161.  
  162.    for (j=0; j<slist->nEntries-1; j++)
  163.    {
  164.       for (i=j; i<slist->nEntries-1; i++)
  165.       {
  166.          i1   = i+1;
  167.          e_i  = slist->Entries[i];
  168.          e_i1 = slist->Entries[i1];
  169.  
  170.          if (strcmp( e_i, e_i1 ) > 0)
  171.          {
  172.             slist->Entries[i]  = e_i1;
  173.             slist->Entries[i1] = e_i;
  174.  
  175.             if (slist->Qualifiers)
  176.             {
  177.                q = slist->Qualifiers[i];
  178.                slist->Qualifiers[i]  = slist->Qualifiers[i1];
  179.                slist->Qualifiers[i1] = q;
  180.             }
  181.          }
  182.       }
  183.    }
  184. }
  185.  
  186.  
  187. BOOL StringList_Dup( StringList *source, StringList *target )
  188. {
  189.    USHORT i, j, n;
  190.  
  191.    if ((n = source->nEntries) >0)
  192.    {
  193.       target->nEntries = n;
  194.  
  195.       if (target->Entries = (char**) Amalloc( n * sizeof(char**)) )
  196.       {
  197.          for (i=0; i<n; i++)
  198.          {
  199.             if (!(target->Entries[i] = Astrdup( source->Entries[i] )))
  200.             {
  201.                /* release memory already allocated. */
  202.                for (j=0; j<i; j++)
  203.                   Afree( target->Entries[j] );
  204.                Afree( target->Entries );
  205.  
  206.                return FALSE;
  207.             }
  208.          }
  209.  
  210.          if (source->Qualifiers)
  211.          {
  212.             if (target->Qualifiers = (UBYTE*) Amalloc( n * sizeof(UBYTE)))
  213.             {
  214.                for (i=0; i<n; i++)
  215.                   target->Qualifiers[i] = source->Qualifiers[i];
  216.             }
  217.             else
  218.             {
  219.                /* release memory already allocated. */
  220.                StringList_CleanUp(target);
  221.                return FALSE;
  222.             }
  223.          }
  224.          return TRUE;
  225.  
  226.       }
  227.    }
  228.    else
  229.    {
  230.       StringList_Init( target, (BOOL) source->Qualifiers );
  231.       return TRUE;
  232.    }
  233. }
  234.  
  235. BOOL StringList_AddStrings( StringList  *slist,
  236.                             char       **strings,
  237.                             BYTE        *qualifiers )
  238. {
  239.    USHORT i;
  240.  
  241.    for(i=0; strings[i] != NULL; i++)
  242.    {
  243.       if (! StringList_AddString( slist, strings[i],
  244.                            (qualifiers ? qualifiers[i] : 0) ) )
  245.          return FALSE;
  246.    }
  247.  
  248.    return TRUE;
  249. }
  250.